// 导入axios实例
import request from '@/utils/request';

/**
 * @description CZML文档包接口定义
 */
interface CzmlDocumentPacket {
  id: string;
  name: string;
  version: string;
  clock: {
    interval: string;
    currentTime: string;
    multiplier: number;
    range: string;
    step: string;
  };
  properties: {
    defaultStyle: {
      markerSymbol: string;
      markerColor: string;
      strokeWidth: number;
      strokeColor: string;
      fillColor: string;
    };
  };
}

/**
 * @description CZML实体包接口定义
 */
interface CzmlEntityPacket {
  id: string;
  name?: string;
  description?: string;
  customType?: string; // 添加自定义类型标识，用于解析时识别实体类型
  properties?: {
    formData?: any; // 添加表单数据字段，用于存储完整的表单数据
    [key: string]: any; // 允许其他属性
  };
  [key: string]: any; // 允许其他属性
}

/**
 * @description 文件管理API接口
 */

/**
 * @description 后端导出CZML文件，前端导入CZML文件
 * @param {number} fileId - 文件ID
 * @param {string} filename - 文件名称
 * @returns {Promise<any>} 返回文件URL
 */
export const uploadCzmlFile = (formData: FormData) => {
  return request({
    url: '/api/files/importCzml',
    method: 'post',
    data: formData,
    headers: {
      'Content-Type': 'multipart/form-data'
    },
    timeout: 30000
  }).then(response => {
    console.log('上传CZML文件 - 响应成功:', response);
    return response;
  }).catch(error => {
    console.error('上传CZML文件 - 请求失败:', error);
    return {
      code: 1,
      msg: '上传文件失败',
      data: error.message || '网络请求异常'
    };
  });
};

export const exportCzmlFile = (fileId: number, filename: string) => {
  return request({
    url: `/api/files/exportCzml`,
    method: 'get',
    params: {
      file_id: fileId,
      filename: filename
    }
  }).then(response => {
    console.log('导出CZML文件 - 响应成功:', response);
    return response;
  }).catch(error => {
    console.error('导出CZML文件 - 请求失败:', error);
    // 构造一个标准格式的错误响应，使用code=1表示失败
    return {
      code: 1,
      msg: '导出文件失败',
      data: error.message || '网络请求异常'
    };
  });
};

/**
 * @description 后端导入CZML文件，前端导出CZML文件
 *  * @param {File} file - 要上传的CZML文件
 * @returns {Promise<any>}
 */
export const importCzmlFile = (file: File) => {
  // 创建FormData对象用于文件上传
  const formData = new FormData();
  formData.append('file', file);
  
  console.log('导入CZML文件 - 文件名:', file.name);
  console.log('导入CZML文件 - 文件大小:', file.size, 'bytes');
  
  return request({
    url: `/api/files/importCzml`,
    method: 'post',
    data: formData,
    headers: {
      'Content-Type': 'multipart/form-data'
    },
    timeout: 30000 // 增加超时时间到30秒
  }).then(response => {
    console.log('导入CZML文件 - 响应成功:', response);
    return response;
  }).catch(error => {
    console.error('导入CZML文件 - 请求失败:', error);
    // 构造一个标准格式的错误响应，使用code=1表示失败
    return {
      code: 1,
      msg: '导入文件失败',
      data: error.message || '网络请求异常'
    };
  });
};

/**
 * @description 查询用户所有CZML文件
 * @returns {Promise<any>} 返回文件列表
 */
export const queryCzmlFiles = () => {
  return request({
    url: `/api/files/queryCzml`,
    method: 'get'
  }).then(response => {
    console.log('查询CZML文件列表 - 响应成功:', response);
    return response;
  }).catch(error => {
    console.error('查询CZML文件列表 - 请求失败:', error);
    // 构造一个标准格式的错误响应，使用code=1表示失败
    return {
      code: 1,
      msg: '获取场景列表失败',
      data: error.message || '网络请求异常'
    };
  });
};

/**
 * @description 删除CZML文件
 * @param {number} fileId - 文件ID
 * @returns {Promise<any>} 返回操作结果
 */
export const deleteCzmlFile = (fileId: number) => {
  return request({
    url: `/api/files/deleteCzml`,
    method: 'delete',
    params: {
      file_id: fileId
    }
  }).then(response => {
    console.log('删除CZML文件 - 响应成功:', response);
    return response;
  }).catch(error => {
    console.error('删除CZML文件 - 请求失败:', error);
    // 构造一个标准格式的错误响应，使用code=1表示失败
    return {
      code: 1,
      msg: '删除文件失败',
      data: error.message || '网络请求异常'
    };
  });
};

/**
 * @description 创建新的CZML文件（新建场景）
 * @param {string} fileName - 文件名称
 * @param {object} sceneData - 场景初始数据
 * @returns {Promise<any>}
 */
export const createCzmlFile = (fileName: string, sceneData: any = {}) => {
  // 构建符合Cesium CZML规范的初始数据结构
  // 获取当前时间作为CZML的时间基准
  const now = new Date();
  const start = new Date(now);
  const end = new Date(now);
  end.setFullYear(end.getFullYear() + 1); // 设置结束时间为一年后
  
  // 格式化时间为ISO字符串
  const startTime = start.toISOString();
  const endTime = end.toISOString();
  const currentTime = now.toISOString();
  
  console.log('创建场景 - 文件名:', fileName);
  
  // 创建文档包作为CZML数据的第一个元素
  const documentPacket: CzmlDocumentPacket = {
    id: "document",
    name: fileName,
    version: "1.0",
    clock: {
      interval: `${startTime}/${endTime}`,
      currentTime: currentTime,
      multiplier: 1,
      range: "UNBOUNDED",
      step: "SYSTEM_CLOCK_MULTIPLIER"
    },
    // 添加全局样式设置
    properties: {
      defaultStyle: {
        markerSymbol: "pin",
        markerColor: "#3388ff",
        strokeWidth: 3,
        strokeColor: "#3388ff",
        fillColor: "rgba(51, 136, 255, 0.2)"
      }
    }
  };
  
  // 初始化CZML数据数组，文档包必须是第一个元素
  const initialCzmlData: (CzmlDocumentPacket | CzmlEntityPacket)[] = [documentPacket];
  
  // 处理场景数据
  if (sceneData && Object.keys(sceneData).length > 0) {
    console.log('处理场景数据类型:', typeof sceneData);
    
    // 处理初始视角数据
    if (sceneData.initialViewpoint) {
      console.log('处理初始视角数据:', sceneData.initialViewpoint);
      if (typeof sceneData.initialViewpoint === 'object') {
        // 为初始视角添加customType标识
        const viewpoint = { ...sceneData.initialViewpoint, customType: 'initialViewpoint' };
        
        // 确保properties对象存在
        if (!viewpoint.properties) {
          viewpoint.properties = {};
        }
        
        // 存储完整的表单数据
        viewpoint.properties.formData = sceneData.initialViewpointFormData || sceneData.initialViewpoint;
        
        initialCzmlData.push(viewpoint);
      }
    }
    
    // 处理卫星数据
    if (sceneData.satellites && Array.isArray(sceneData.satellites)) {
      console.log('处理卫星数据, 数量:', sceneData.satellites.length);
      sceneData.satellites.forEach((satellite: any) => {
        if (satellite && typeof satellite === 'object' && satellite.id) {
          // 为卫星添加customType标识
          const satelliteEntity = { ...satellite, customType: 'satellite' };
          
          // 确保properties对象存在
          if (!satelliteEntity.properties) {
            satelliteEntity.properties = {};
          }
          
          // 存储完整的表单数据
          satelliteEntity.properties.formData = satellite.formData || satellite;
          
          initialCzmlData.push(satelliteEntity);
        }
      });
    }
    
    // 处理地面站数据
    if (sceneData.groundStations && Array.isArray(sceneData.groundStations)) {
      console.log('处理地面站数据, 数量:', sceneData.groundStations.length);
      sceneData.groundStations.forEach((station: any) => {
        if (station && typeof station === 'object' && station.id) {
          // 为地面站添加customType标识
          const stationEntity = { ...station, customType: 'groundStation' };
          
          // 确保properties对象存在
          if (!stationEntity.properties) {
            stationEntity.properties = {};
          }
          
          // 存储完整的表单数据
          stationEntity.properties.formData = station.formData || station;
          
          initialCzmlData.push(stationEntity);
        }
      });
    }
    
    // 处理区域目标数据
    if (sceneData.areaTargets && Array.isArray(sceneData.areaTargets)) {
      console.log('处理区域目标数据, 数量:', sceneData.areaTargets.length);
      sceneData.areaTargets.forEach((target: any) => {
        if (target && typeof target === 'object' && target.id) {
          // 为区域目标添加customType标识
          const targetEntity = { ...target, customType: 'areaTarget' };
          
          // 确保properties对象存在
          if (!targetEntity.properties) {
            targetEntity.properties = {};
          }
          
          // 存储完整的表单数据
          targetEntity.properties.formData = target.formData || target;
          
          initialCzmlData.push(targetEntity);
        }
      });
    }
    
    // 处理点目标数据
    if (sceneData.pointTargets && Array.isArray(sceneData.pointTargets)) {
      console.log('处理点目标数据, 数量:', sceneData.pointTargets.length);
      sceneData.pointTargets.forEach((target: any) => {
        if (target && typeof target === 'object' && target.id) {
          // 为点目标添加customType标识
          const targetEntity = { ...target, customType: 'pointTarget' };
          
          // 确保properties对象存在
          if (!targetEntity.properties) {
            targetEntity.properties = {};
          }
          
          // 存储完整的表单数据
          targetEntity.properties.formData = target.formData || target;
          
          initialCzmlData.push(targetEntity);
        }
      });
    }
    
    // 处理载荷数据
    if (sceneData.payloads && Array.isArray(sceneData.payloads)) {
      console.log('处理载荷数据, 数量:', sceneData.payloads.length);
      sceneData.payloads.forEach((payload: any) => {
        if (payload && typeof payload === 'object' && payload.id) {
          // 为载荷添加customType标识
          const payloadEntity = { ...payload, customType: 'payload' };
          
          // 确保properties对象存在
          if (!payloadEntity.properties) {
            payloadEntity.properties = {};
          }
          
          // 存储完整的表单数据
          payloadEntity.properties.formData = payload.formData || payload;
          
          initialCzmlData.push(payloadEntity);
        }
      });
    }
  }
  
  // 将CZML数据转换为Blob
  try {
    const czmlString = JSON.stringify(initialCzmlData);
    console.log('创建场景 - CZML数据结构生成完成, 总对象数:', initialCzmlData.length);
    
    const czmlBlob = new Blob([czmlString], { type: 'application/json' });
    
    // 创建File对象
    const czmlFile = new File([czmlBlob], `${fileName}.czml`, { type: 'application/json' });
    
    // 调用导入接口上传文件
    return importCzmlFile(czmlFile)
      .then(response => {
        console.log('创建场景 - 导入结果:', response);
        return response;
      })
      .catch(error => {
        console.error('创建场景 - 导入失败:', error);
        throw error;
      });
  } catch (error) {
    console.error('创建场景 - 数据处理失败:', error);
    throw error;
  }
};

/**
 * 写来玩玩，这个方法目前没被调用，因为目前就打开场景要用，但是打开场景已经实现了，以后要用再说
 * @description 从URL获取CZML文件内容
 * @param {string} url - CZML文件URL
 * @returns {Promise<any>} 返回解析后的CZML数据
 */
export const fetchCzmlFromUrl = async (url: string) => {
  try {
    console.log('获取CZML文件内容 - URL:', url);
    
    // 使用fetch API获取文件内容
    const response = await fetch(url);
    if (!response.ok) {
      throw new Error(`获取文件内容失败: ${response.status} ${response.statusText}`);
    }
    
    // 解析JSON数据
    const czmlData = await response.json();
    console.log('CZML文件内容解析成功, 对象数量:', czmlData.length);
    
    return czmlData;
  } catch (error) {
    console.error('获取CZML文件内容失败:', error);
    throw error;
  }
};
